home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / flxlstc.exe / FLEXLIST.HKR < prev   
Text File  |  1990-10-04  |  6KB  |  187 lines
  1. /*
  2.     flexlist.hkr
  3.     10-4-90
  4.     Homogeneous-heterogeneous 
  5.     hybrid stack-queue-list-array generic class.
  6.     K&R C
  7.  
  8.     Copyright 1990
  9.     John W. Small
  10.     All rights reserved
  11.  
  12.     PSW / Power SoftWare
  13.     P.O. Box 10072
  14.     McLean, Virginia 22102 8072
  15.     (703) 759-3838
  16. */
  17.  
  18. /* LINTLIBRARY */
  19.  
  20. #ifndef FLEXLIST_KR_C
  21. #define FLEXLIST_KR_C
  22.  
  23. typedef unsigned size_t;
  24. #define UINT_MAX -1
  25. typedef char void;
  26. #define const
  27.  
  28.  
  29. /*  FlexNode declarations  */
  30.  
  31. typedef struct FlexNode_ FlexNode, *FlexN;
  32. #define FlexN0 ((FlexN)0)
  33. #define FlexNodeLinkage FlexN next, prev
  34.  
  35. struct FlexNode_ {
  36. /*  friend: FlexList  */
  37.     FlexNodeLinkage;
  38. /*  public:  */
  39.     char data[1];
  40. };
  41.  
  42. /*  Virtual functions for variant FlexNodes  */
  43.  
  44. typedef struct  {
  45. /*  friend: FlexList  */
  46.     FlexN (*FNnew)(/* const void *D */);
  47.     int   (*FNwrite)(/* void *ND, const void *D */);
  48.     int   (*FNread)(/* const void *ND, void *D */);
  49.     int   (*FNdestruct)(/* void *ND, void *D */);
  50. } FlexNodeVFT, *FlexNVFT;
  51.  
  52. #define FlexNVFT0 ((FlexNVFT)0)
  53. #define FNnew0 ((FlexN (*)(/* const void *D */)) 0)
  54. #define FNwrite0 ((int (*)(/* void *ND, const void *D */)) 0)
  55. #define FNread0 ((int (*)(/* const void *ND, void *D */)) 0)
  56. #define FNdestruct0 ((int (*)(/* void *ND, void *D */)) 0)
  57.  
  58.  
  59. /*  String variant FlexNode functions  */
  60. extern  FlexNodeVFT FlexNodeStrVFT;
  61.  
  62.  
  63. /*  FlexList header declaration  */
  64.  
  65. typedef struct  {
  66. /*  private:  */
  67.     FlexN  front, current, rear;
  68.     unsigned curNum, nodes, maxNodes;
  69.     size_t sizeofNodeData, sizeofNode;
  70.     int sorted;
  71.     int (*compare)(/* const void *D1, const void *D2 */);
  72.     FlexNVFT vft;
  73.     int (*FLDdestruct)(/* void *LD */);
  74.     char data[1];
  75. } FlexList, *FlexL;
  76.  
  77. #define FlexL0 ((FlexL)0)
  78. #define FLcomparE(compare)  ((int (*)(/* const void *D1, \
  79.         const void *D2 */)) compare)
  80. #define FLcompare0  FLcomparE(0)
  81. #define FLDdestruct0 ((int (*)(/* void *LD */)) 0)
  82.  
  83.  
  84. /*  FlexList constructors/destructor - static headers  */
  85. extern  FlexL FLfixed(/* FlexL L, size_t sizeofNodeData */);
  86. extern  FlexL FLunpack(/* FlexL L, size_t sizeofCell, 
  87.         unsigned cells, const void *array */);
  88. extern  FlexL FLvariant(/* FlexL L, FlexNVFT vft */);
  89. #define FLstr(L) FLvariant(/* L,&FlexNodeStrVFT */)
  90. extern  int   FLclear(/* FlexL L */);
  91.  
  92. /*  FlexList constructors/destructor - dynamic headers  */
  93. extern  FlexL FLfixedNew(/* size_t sizeofNodeData,
  94.         size_t sizeofLocalData, 
  95.         int (*FLDdestruct)(void *LD) */);
  96. extern  FlexL FLunpackNew(/* size_t sizeofCell, 
  97.         unsigned cells, const void *array,
  98.         size_t sizeofLocalData,
  99.         int (*FLDdestruct)(void *LD) */);
  100. extern  FlexL FLvariantNew(/* FlexNVFT vft,
  101.         size_t sizeofLocalData, 
  102.         int (*FLDdestruct)(void *LD) */);
  103. #define FLstrNew(sizeofLocalData, FLDdestruct)  \
  104.         FLvariantNew(&FlexNodeStrVFT,  \
  105.             sizeofLocalData,FLDdestruct)
  106. extern  int   FLdelete(/* FlexL *Lptr */);
  107.  
  108.  
  109. /*  FlexList header functions  */
  110. #define FLfrontD(L) (void *)((L)? (L)->front? \
  111.         (L)->front->data : 0 : 0)
  112. #define FLcurrentD(L) (void *)((L)? (L)->current? \
  113.         (L)->current->data : 0 : 0)
  114. #define FLrearD(L) (void *)((L)? (L)->rear? \
  115.         (L)->rear->data : 0 : 0)
  116. #define FLcurNum(L) ((L)? (L)->curNum : 0)
  117. #define FLnodes(L)  ((L)? (L)->nodes : 0)
  118. #define FLmaxNodes(L) ((L)? (L)->maxNodes : 0)
  119. extern  int   FLsetMaxNodes(/* FlexL L, unsigned maxNodes */);
  120. #define FLnotFull(L) ((L)? ((L)->maxNodes - (L)->nodes) : 0)
  121. #define FLsizeofNodeData(L) ((L)? (L)->sizeofNodeData : 0)
  122. #define FLisSorted(L)  ((L)? (L)->sorted : 0)
  123. #define FLunSort(L)  ((L)? ((L)->sorted = 0, 1) : 0)
  124. #define FLcompare(L)  ((L)? (L)->compare : FLcompare0)
  125. extern  int   FLsetCompare(/* FlexL L, int (*compare)
  126.         (const void *D1, const void *D2) */);
  127. #define FLisFixed(L)  FLsizeofNodeData(L)
  128. #define FLisVariant(L) ((L)? (L)->vft : FlexNVFT0)
  129. #define FLData(L)  (void *)((L)? ((L)->FLDdestruct?  \
  130.         (L)->data : 0) : 0)
  131.  
  132. /*  FlexList stack and queue functions  */
  133. extern  void *FLpushN(/* FlexL L, FlexN N */);
  134. extern  void *FLpushD(/* FlexL L, const void *D */);
  135. extern  FlexN FLpopN(/* FlexL L */);
  136. extern  int   FLpopD(/* FlexL L, void *D */);
  137. extern  void *FLtopD(/* FlexL L, void *D */);
  138. extern  void *FLinsQN(/* FlexL L, FlexN N */);
  139. extern  void *FLinsQD(/* FlexL L, const void *D */);
  140.  
  141. /*  FlexList list functions  */
  142. extern  void *FLmkcur(/* FlexL L, unsigned n */);
  143. extern  void *FLinsN(/* FlexL L, FlexN N */);
  144. extern  void *FLinsD(/* FlexL L, const void *D */);
  145. extern  void *FLinsSortN(/* FlexL L, FlexN N */);
  146. extern  void *FLinsSortD(/* FlexL L, const void *D */);
  147. extern  FlexN FLdelN(/* FlexL L */);
  148. extern  int   FLdelD(/* FlexL L, void *D */);
  149. extern  void *FLnextD(/* FlexL L, void *D */);
  150. extern  void *FLprevD(/* FlexL L, void *D */);
  151.  
  152.  
  153.  
  154. /*  FlexList search/sort functions  */
  155. /*  See also FLinsSortN()/FLinsSortD() list functions  */
  156. extern  void *FLfindFirstD(/* FlexL L, const void *D */);
  157. extern  void *FLfindNextD(/* FlexL L, const void *D */);
  158. extern  void *FLfindLastD(/* FlexL L, const void *D */);
  159. extern  void *FLfindPrevD(/* FlexL L, const void *D */);
  160. extern  int   FLsort(/* FlexL L, int (*compare)
  161.         (const void *D1, const void *D2) */);
  162.  
  163. /*  FlexList array functions  */
  164. /*  See also compaction functions */
  165. extern  int   FLstoreD(/* FlexL L, const void *D, unsigned n */);
  166. extern  int   FLrecallD(/* FlexL L, void *D, unsigned n */);
  167.  
  168. /*  FlexList compaction functions  */
  169. /*  See also FLunpack()/FLunpackNew() constructors  */
  170. extern  void *FLpack(/* FlexL L */);
  171. extern  void **FLpackPtrs(/* FlexL L */);
  172.  
  173. /*  FlexList implementation constants  */
  174. /*  Change as required by target machine  */
  175. #define FLmaxMaxNodes  UINT_MAX
  176. #define FLmallocAlignLoss  16
  177. #define FLmaxSizeofLocalData \
  178.     ((size_t)(-(long)sizeof(FlexList) \
  179.     -FLmallocAlignLoss))
  180. #define FLmaxSizeofNodeData  \
  181.     ((size_t)(-(long)sizeof(FlexNode) \
  182.     -FLmallocAlignLoss))
  183. #define FLmaxSizeofArray \
  184.     ((long)(size_t)-FLmallocAlignLoss)
  185.  
  186. #endif
  187.